Page({
  /**
   * 页面的初始数据
   */
  data: {
    artistId: "",
    artistInfo: null,
    songs: [],
    loading: true,
    // 底部播放栏相关数据
    nowPlaying: {
      id: null,
      title: "暂无播放",
      artist: "未知歌手",
      coverUrl: "",
    },
    isPlaying: false,
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    const artistId = options.id;
    if (!artistId) {
      wx.showToast({
        title: "参数错误",
        icon: "none",
      });
      wx.navigateBack();
      return;
    }

    console.log("加载歌手详情，ID:", artistId);
    this.setData({ artistId });

    // 首先创建一个基本的艺术家信息对象，以防API调用失败
    this.createBasicArtistInfo(artistId);

    // 获取详细信息
    this.fetchArtistDetail(artistId);
    this.fetchArtistSongs(artistId);

    // 检查当前播放状态
    this.checkNowPlaying();
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    // 检查当前播放状态
    this.checkNowPlaying();
  },

  /**
   * 检查当前播放的歌曲
   */
  checkNowPlaying: function () {
    try {
      const app = getApp();
      const bgAudioManager = wx.getBackgroundAudioManager();

      if (!bgAudioManager) {
        console.error("无法获取背景音频管理器");
        return;
      }

      // 检查当前是否有歌曲在播放
      const hasSong = bgAudioManager.src && bgAudioManager.src.length > 0;
      const isPlaying = hasSong && !bgAudioManager.paused;

      console.log(
        "当前播放状态:",
        hasSong ? "有歌曲" : "无歌曲",
        isPlaying ? "正在播放" : "已暂停"
      );

      // 从全局数据更新本地数据
      if (
        app.globalData &&
        app.globalData.nowPlaying &&
        app.globalData.nowPlaying.id
      ) {
        this.setData({
          nowPlaying: app.globalData.nowPlaying,
          isPlaying: isPlaying,
        });
      } else if (hasSong) {
        // 如果全局数据中没有当前播放信息，但后台音频管理器有播放内容，创建一个基本播放信息
        this.setData({
          nowPlaying: {
            id: bgAudioManager.id || 0,
            title: bgAudioManager.title || "未知歌曲",
            artist: bgAudioManager.singer || "未知歌手",
            coverUrl: bgAudioManager.coverImgUrl || "",
          },
          isPlaying: isPlaying,
        });
      }

      // 注册播放状态变化回调
      if (app) {
        app.playStatusCallback = (isPlaying) => {
          console.log("播放状态变化:", isPlaying ? "播放" : "暂停");
          this.setData({ isPlaying });
        };

        // 注册歌曲变化回调
        app.songChangeCallback = (song) => {
          console.log("歌曲变化:", song.title);
          this.setData({
            nowPlaying: song,
            isPlaying: true,
          });
        };
      }
    } catch (error) {
      console.error("检查播放状态出错:", error);
    }
  },

  /**
   * 创建基本艺术家信息
   */
  createBasicArtistInfo: function (artistId) {
    // 使用搜索页面传过来的信息或设置一个默认值
    const pages = getCurrentPages();
    const prevPage = pages.length > 1 ? pages[pages.length - 2] : null;

    let basicInfo = {
      id: artistId,
      name: "加载中...",
      avatar: "",
      musicSize: 0,
      briefDesc: "加载中...",
    };

    // 如果有上一页且有艺术家信息，则使用上一页的信息
    if (prevPage && prevPage.data && prevPage.data.artistInfo) {
      const prevArtistInfo = prevPage.data.artistInfo;
      if (prevArtistInfo.id == artistId) {
        basicInfo = { ...prevArtistInfo };
      }
    }

    this.setData({ artistInfo: basicInfo });
  },

  /**
   * 获取歌手详情
   */
  fetchArtistDetail: function (artistId) {
    const that = this;
    console.log("开始获取歌手详情, ID:", artistId);

    // 获取Token
    const token = wx.getStorageSync("access_token");

    wx.request({
      url: "https://smartsound.top/artist/detail",
      method: "GET",
      data: {
        id: artistId,
      },
      header: {
        Authorization: token ? `Bearer ${token}` : "",
        "content-type": "application/json",
      },
      success(res) {
        console.log("歌手详情:", res.data);

        if (res.data && res.data.data && res.data.data.artist) {
          const artistData = res.data.data.artist;
          console.log("获取到歌手数据:", artistData);

          // 构建歌手信息对象
          const artistInfo = {
            id: artistId,
            name: artistData.name || that.data.artistInfo.name || "未知歌手",
            avatar:
              artistData.cover ||
              artistData.picUrl ||
              artistData.img1v1Url ||
              that.data.artistInfo.avatar ||
              "",
            musicSize: artistData.musicSize || 0,
            briefDesc: artistData.briefDesc || "",
            introduction: res.data.data.introduction || [],
          };

          // 更新歌手信息
          that.setData({
            artistInfo: artistInfo,
            loading: false,
          });
        } else if (res.data && res.data.artist) {
          // 兼容不同的API返回结构
          const artistData = res.data.artist;
          console.log("获取到歌手数据(兼容格式):", artistData);

          // 更新艺术家信息
          const artistInfo = {
            id: artistId,
            name: artistData.name || that.data.artistInfo.name || "未知歌手",
            avatar:
              artistData.cover ||
              artistData.picUrl ||
              artistData.img1v1Url ||
              that.data.artistInfo.avatar ||
              "",
            musicSize: artistData.musicSize || 0,
            briefDesc: artistData.briefDesc || "",
            introduction: res.data.introduction || [],
          };

          that.setData({
            artistInfo: artistInfo,
            loading: false,
          });
        } else {
          that.setData({ loading: false });
          console.log("歌手详情数据格式不符合预期:", res.data);
        }
      },
      fail(err) {
        console.error("获取歌手详情失败:", err);
        that.setData({ loading: false });
      },
    });
  },

  /**
   * 获取歌手歌曲
   */
  fetchArtistSongs: function (artistId) {
    const that = this;
    console.log("开始获取歌手歌曲, ID:", artistId);

    // 获取Token
    const token = wx.getStorageSync("access_token");

    wx.request({
      url: "https://smartsound.top/artist/songs",
      method: "GET",
      data: {
        id: artistId,
        limit: 50,
        offset: 0,
      },
      header: {
        Authorization: token ? `Bearer ${token}` : "",
        "content-type": "application/json",
      },
      success(res) {
        console.log("歌手歌曲信息:", res.data);

        if (res.data && res.data.songs) {
          // 输出第一首歌曲的完整数据结构，用于调试
          if (res.data.songs.length > 0) {
            console.log("歌曲数据示例:", JSON.stringify(res.data.songs[0]));
          }

          // 处理歌曲数据
          const songs = res.data.songs.map((song) => {
            // 处理歌曲封面 - 优先使用专辑封面
            let picUrl = "";

            // 尝试获取专辑封面的多种格式
            if (song.al && song.al.pic_str) {
              // 网易云音乐图片 URL 格式
              picUrl = `https://music.163.com/api/img/blur/${song.al.pic_str}`;
            } else if (song.al && song.al.picUrl) {
              picUrl = song.al.picUrl;
            } else if (song.album && song.album.picUrl) {
              picUrl = song.album.picUrl;
            } else if (song.album && song.album.pic_url) {
              picUrl = song.album.pic_url;
            } else if (song.album && song.album.pic_str) {
              picUrl = `https://music.163.com/api/img/blur/${song.album.pic_str}`;
            } else if (song.picUrl) {
              picUrl = song.picUrl;
            } else if (song.pic_str) {
              picUrl = `https://music.163.com/api/img/blur/${song.pic_str}`;
            } else if (song.coverImgUrl) {
              picUrl = song.coverImgUrl;
            } else {
              // 使用默认图标，不使用歌手头像
              picUrl = "/assets/music-icon.png";
            }

            // 如果封面URL是相对路径（不是以http开头），添加域名前缀
            if (
              picUrl &&
              !picUrl.startsWith("/assets/") &&
              !picUrl.startsWith("http")
            ) {
              picUrl = `https://music.163.com${picUrl}`;
            }

            // 替换大小参数，获取更高质量的图片
            if (picUrl && picUrl.includes("?param=")) {
              picUrl = picUrl.replace(/\?param=\d+y\d+$/, "?param=300y300");
            }

            console.log("处理歌曲:", song.name, "封面URL:", picUrl);

            // 获取歌手ID
            let artistId = 0;
            if (song.ar && song.ar.length > 0) {
              artistId = song.ar[0].id;
            } else if (song.artists && song.artists.length > 0) {
              artistId = song.artists[0].id;
            }

            // 获取专辑名称
            let album = "";
            if (song.al && song.al.name) {
              album = song.al.name;
            } else if (song.album && song.album.name) {
              album = song.album.name;
            }

            return {
              id: song.id,
              name: song.name,
              artist:
                (song.ar && song.ar[0] && song.ar[0].name) ||
                (song.artists && song.artists[0] && song.artists[0].name) ||
                "未知歌手",
              picUrl: picUrl, // 修改为picUrl与songs页面保持一致
              coverUrl: picUrl, // 保留coverUrl兼容之前的代码
              artistId: artistId,
              album: album, // 添加专辑信息
              // 完整歌曲信息，用于播放
              song: song,
            };
          });

          that.setData({ songs });
        }
      },
      fail(err) {
        console.error("获取歌手歌曲失败:", err);
      },
    });
  },

  /**
   * 播放歌曲
   */
  playSong: function (e) {
    const songId = e.currentTarget.dataset.id;
    const songInfo = this.getSongById(songId);

    console.log("播放歌曲:", songId, songInfo.name);

    // 获取全局app
    const app = getApp();

    // 如果已有播放列表，则先保存
    if (!app.globalData.currentSongList) {
      app.globalData.currentSongList = [];
    }

    // 将当前歌手的歌曲列表设置为播放列表
    if (this.data.songs.length > 0) {
      app.globalData.currentSongList = this.data.songs.map((song) => song.song);
    }

    // 播放选中的歌曲
    app.playSong(songInfo.song);

    // 更新本地播放状态
    this.setData({
      nowPlaying: {
        id: songInfo.id,
        title: songInfo.name,
        artist: songInfo.artist,
        coverUrl: songInfo.picUrl, // 使用picUrl替代coverUrl
      },
      isPlaying: true,
    });

    // 跳转到歌曲详情页
    wx.navigateTo({
      url: `/pages/song/song?id=${songId}&name=${encodeURIComponent(
        songInfo.name
      )}`,
    });
  },

  /**
   * 根据ID获取歌曲信息
   */
  getSongById: function (songId) {
    if (this.data.songs && this.data.songs.length > 0) {
      const found = this.data.songs.find((song) => song.id == songId);
      if (found) return found;
    }

    // 如果找不到，构建一个基本的歌曲信息对象
    let defaultCoverUrl = "/assets/music-icon.png"; // 直接使用默认图标

    return {
      id: songId,
      name: "未知歌曲",
      artist: "未知歌手",
      coverUrl: defaultCoverUrl,
      album: "未知专辑",
      song: {
        id: songId,
        name: "未知歌曲",
        ar: [{ id: 0, name: "未知歌手" }],
        al: { id: 0, name: "未知专辑", picUrl: defaultCoverUrl },
      },
    };
  },

  /**
   * 处理底部播放栏点击
   */
  handleNowPlayingTap: function () {
    if (this.data.nowPlaying.id) {
      // 跳转到歌曲详情页
      wx.navigateTo({
        url: `/pages/song/song?id=${this.data.nowPlaying.id}`,
      });
    }
  },

  /**
   * 切换播放状态
   */
  togglePlayState: function (e) {
    // 阻止冒泡，防止触发父元素的点击事件
    // 只有当e是有效的事件对象时才调用stopPropagation
    if (e && typeof e.stopPropagation === "function") {
      e.stopPropagation();
    }

    console.log("触发播放/暂停按钮");

    // 获取全局app实例
    const app = getApp();

    // 获取背景音频管理器
    const bgAudioManager = wx.getBackgroundAudioManager();

    // 显示调试信息
    console.log("音频管理器信息:", {
      src: bgAudioManager.src ? "有音频" : "无音频",
      paused: bgAudioManager.paused ? "已暂停" : "播放中",
      currentTime: bgAudioManager.currentTime || 0,
      duration: bgAudioManager.duration || 0,
      title: bgAudioManager.title || "无标题",
    });

    // 检查是否有正在播放的音频
    if (!bgAudioManager.src) {
      wx.showToast({
        title: "暂无播放歌曲",
        icon: "none",
        duration: 1500,
      });
      return;
    }

    // 根据当前播放状态执行相反操作
    const isCurrentlyPlaying = !bgAudioManager.paused;

    if (isCurrentlyPlaying) {
      // 当前在播放，执行暂停
      try {
        console.log("执行暂停操作");
        bgAudioManager.pause();

        // 更新UI状态
        this.setData({ isPlaying: false });

        // 反馈给用户
        wx.showToast({
          title: "已暂停",
          icon: "none",
          duration: 1000,
        });

        // 同步全局状态
        if (app && app.globalData) {
          app.globalData.isPlaying = false;
        }
      } catch (error) {
        console.error("暂停操作失败:", error);
      }
    } else {
      // 当前已暂停，执行播放
      try {
        console.log("执行播放操作");
        bgAudioManager.play();

        // 更新UI状态
        this.setData({ isPlaying: true });

        // 反馈给用户
        wx.showToast({
          title: "播放中",
          icon: "none",
          duration: 1000,
        });

        // 同步全局状态
        if (app && app.globalData) {
          app.globalData.isPlaying = true;
        }
      } catch (error) {
        console.error("播放操作失败:", error);
      }
    }
  },
});
